package br.com.foxinline.servico;

import br.com.foxinline.enums.EstadoCivil;
import br.com.foxinline.enums.Relatorio;
import br.com.foxinline.enums.TipoDocumento;
import br.com.foxinline.generico.ServicoGenerico;
import br.com.foxinline.modelo.Anexo;
import br.com.foxinline.modelo.Imovel;
import br.com.foxinline.modelo.Proprietario;
import br.com.foxinline.util.ArquivoUtilitario;
import br.com.foxinline.util.Caracter;
import br.com.foxinline.util.GrupoUtilitario;
import br.com.foxinline.util.Msg;
import java.beans.Transient;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import javax.annotation.security.DeclareRoles;
import javax.annotation.security.RolesAllowed;
import javax.ejb.EJB;
import javax.ejb.Stateless;
import javax.persistence.NoResultException;
import javax.persistence.NonUniqueResultException;
import javax.persistence.Query;

/**
 *
 * @author laverson
 */
@Stateless
@DeclareRoles(GrupoUtilitario.ADMINISTRADOR)
public class ProprietarioServico extends ServicoGenerico<Proprietario> {

    @EJB
    ImovelServico imovelServico;
    @EJB
    AnexoServico anexoServico;
    private Long quantidadeRegistrosResults;
    private ArquivoUtilitario arquivoUtilitario;

    public ProprietarioServico() {
        super(Proprietario.class);
        arquivoUtilitario = new ArquivoUtilitario();
    }

    /**
     * Utilizar o método salvar
     *
     * @param entity
     * @deprecated
     */
    @Override
    @Deprecated
    public void save(Proprietario entity) {
    }

    /**
     *
     * @param existProprietario retorna uma pessoa física ou jurídica
     */
    public Proprietario existProprietario(TipoDocumento td, String doc) {

        Proprietario proprietario;
        String sql = "Select p from " + Proprietario.class.getSimpleName() + " p where ";

        if (td.equals(TipoDocumento.CPF)) {
            sql += " lower(p.cpf) ";
        } else {
            sql += " lower(p.cnpj) ";
        }

        sql += " like lower(:doc)";

        sql += " and p.ativo=true";

        Query query = getEntityManager().createQuery(sql);
        query.setParameter("doc", Caracter.removecaracter(doc));

        try {
            proprietario = (Proprietario) query.getResultList().get(0);

        } catch (NoResultException nr) {
            return null;
        } catch (NonUniqueResultException nre) {
            return null;
        } catch (Exception e) {
            return null;
        }

        return proprietario;
    }

    /**
     *
     * @param existDocuments verifica se existe do documento e retorna um Proprietario
     */
    public Proprietario existDocuments(Proprietario p) {
        removeCaracterDocument(p);
        Proprietario pe = existProprietario(p.getTipoDocumento(), typeDocument(p));
        if (pe != null) {
            p = pe;
            if (p.getCnpj() != null) {
                p.setTipoDocumento(TipoDocumento.CNPJ);
            } else if (p.getCpf() != null) {
                p.setTipoDocumento(TipoDocumento.CPF);
            }
        } else {

            if (p.getCnpj() != null) {
                String cnpj;
                cnpj = p.getCnpj();
                p = new Proprietario();
                p.setTipoDocumento(TipoDocumento.CNPJ);
                p.setCnpj(cnpj);

            } else if (p.getCpf() != null) {
                String cpf;
                cpf = p.getCpf();
                p = new Proprietario();
                p.setTipoDocumento(TipoDocumento.CPF);
                p.setCpf(cpf);

            }
        }
        return p;
    }

    /**
     *
     * @param typeDocument retorna o tipo de documento
     */
    public String typeDocument(Proprietario p) {
        return p.getTipoDocumento() == TipoDocumento.CPF ? p.getCpf() : p.getCnpj();
    }

    /**
     *
     * @param findProprietario pesquisa
     */
    public List<Proprietario> findProprietario(Proprietario p) {
        String sql = "select p from Proprietario p WHERE ";

        if (p.getTipoDocumento() == TipoDocumento.CPF) {
            if (p.getNome() != null && !p.getNome().equals("")) {
                sql += " lower(p.nome) like lower(:name) and ";
            }
            if (p.getCpf() != null && !p.getCpf().equals("")) {
                sql += " lower(p.cpf) like lower(:cpf) and  ";
            }
        }
        if (p.getTipoDocumento() == TipoDocumento.CNPJ) {
            if (p.getNomeFantasia() != null && !p.getNomeFantasia().equals("")) {
                sql += " lower(p.nomeFantasia) like lower(:name_s) and ";
            }
            if (p.getCnpj() != null && !p.getCnpj().equals("")) {
                sql += " lower(p.cnpj) like lower(:cnpj) and  ";
            }
        }
        sql += " p.ativo = true";
        Query query = getEntityManager().createQuery(sql);

        if (p.getTipoDocumento() == TipoDocumento.CPF) {
            if (p.getNome() != null && !p.getNome().equals("")) {
                query.setParameter("name", "%" + p.getNome() + "%");
            }
            if (p.getCpf() != null && !p.getCpf().equals("")) {
                query.setParameter("cpf", "%" + p.getCpf() + "%");
            }
        }
        if (p.getTipoDocumento() == TipoDocumento.CNPJ) {
            if (p.getNomeFantasia() != null && !p.getNomeFantasia().equals("")) {
                query.setParameter("name_s", "%" + p.getNomeFantasia() + "%");
            }
            if (p.getCnpj() != null && !p.getCnpj().equals("")) {
                query.setParameter("cnpj", "%" + p.getCnpj() + "%");
            }
        }
        return query.getResultList();
    }

    /**
     *
     * @param removeCaracterDocument remove os caracteres que são utilizados como máscara
     */
    public void removeCaracterDocument(Proprietario p) {
        p.setCpf(Caracter.removecaracter(p.getCpf()));
        p.setCnpj(Caracter.removecaracter(p.getCnpj()));

    }

    /**
     * <pre>Busca por todas as "Pessoas" pelo nome</pre>
     *
     * @param <b>name</b> string contendo todo/parte do nome da pessoa
     * @return Uma lista contendo todos as pessoas que possuem "name" em seu nome, <b>null</b> caso não encontre nenhum
     * resultado
     */
    public List<Proprietario> autocompletePessoaFisica(String name) {
        List<Proprietario> results;
        String sql = "Select p from Proprietario p where "
                + "lower(p.tipoDocumento) like lower(:cpf)";

        if (name != null) {
            sql += " and lower(p.nome) like lower(:name)";
        }

        sql += " and (lower(p.nome) not like lower('%imovel%') ";
        sql += " and lower(p.nome) not like lower('%imóvel%')) ";

        Query query = getEntityManager().createQuery(sql).setMaxResults(50);
        query.setParameter("cpf", "%" + TipoDocumento.CPF.getTipo() + "%");

        if (name != null) {
            query.setParameter("name", "%" + name + "%");
        }

        results = query.getResultList();

        return results;
    }

    /**
     * <pre>Busca por todas as "Pessoas" pelo nome fantasia</pre>
     *
     * @param <b>name</b> string contendo todo/parte do nome da pessoa
     * @return Uma lista contendo todos as pessoas que possuem "name" em seu nome, <b>null</b> caso não encontre nenhum
     * resultado
     */
    public List<Proprietario> autocompletePessoaJuridica(String name) {
        List<Proprietario> results;
        String sql = "Select p from Proprietario p where "
                + "lower(p.tipoDocumento) like lower(:cnpj)";

        if (name != null) {
            sql += " and lower(p.nomeFantasia) like lower(:name) ";
        }

        sql += " and lower(p.nome) not like lower('%imovel%') ";
        sql += " or lower(p.nome) not like lower('%imóvel%') ";

        Query query = getEntityManager().createQuery(sql).setMaxResults(50);
        query.setParameter("cnpj", "%" + TipoDocumento.CNPJ.getTipo() + "%");

        if (name != null) {
            query.setParameter("name", "%" + name + "%");
        }

        results = query.getResultList();
        return results;
    }

    /**
     * <pre>Busca por todas as "Pessoas" pelo nome ou nome fantasia</pre>
     *
     * @param <b>name</b> string contendo todo/parte do nome da pessoa
     * @return Uma lista contendo todos as pessoas que possuem "name" em seu nome ou noe fantasia, <b>null</b> caso não
     * encontre nenhum resultado
     */
    public List<Proprietario> autocompletePessoa(String name) {
        List<Proprietario> results;
        String sql = "Select p from Proprietario p where ";

        if (name != null) {
            sql += " ((p.nome is not null and lower(p.nome) like lower(:name)) ";
            sql += " or (p.nomeFantasia is not null and lower(p.nomeFantasia) like lower(:name))) and ";
        }

        sql += " (lower(p.nome) not like lower('%imovel%') ";
        sql += " or lower(p.nome) not like lower('%imóvel%') ";
        sql += " and lower(p.nomeFantasia) not like lower('%imovel%') ";
        sql += " or lower(p.nomeFantasia) not like lower('%imóvel%')) ";

        Query query = getEntityManager().createQuery(sql).setMaxResults(50);

        if (name != null) {
            query.setParameter("name", "%" + name.replaceAll(" ", "%") + "%");
        }

        results = query.getResultList();
        return results;
    }

    public boolean salvar(Proprietario entity) {

        if (entity.getTipoDocumento().equals(TipoDocumento.CPF)) {
            if (entity.getCpf() != null && !entity.getCpf().equals("")) {
                entity.setCpf(Caracter.removecaracter(entity.getCpf()));
            }
            if (entity.getRg() != null && !entity.getRg().equals("")) {
                entity.setRg(Caracter.removecaracter(entity.getRg()));
            }
        } else {
            if (entity.getCnpj() != null && !entity.getCnpj().equals("")) {
                entity.setCnpj(Caracter.removecaracter(entity.getCnpj()));
            }
        }

        if (entity.getTelefone() != null && !entity.getTelefone().isEmpty()) {
            entity.setTelefone(Caracter.removecaracter(entity.getTelefone()));
        }

        boolean existeProprietario;

        if (entity.getTipoDocumento().equals(TipoDocumento.CPF)) {
            existeProprietario = existProprietario(TipoDocumento.CPF, entity.getCpf()) == null;
        } else {
            existeProprietario = existProprietario(TipoDocumento.CNPJ, entity.getCnpj()) == null;
        }

        if (existeProprietario) {

            if (entity.getEstadoCivil() != null && !entity.getEstadoCivil().equals(EstadoCivil.CASADO) && !entity.getEstadoCivil().equals(EstadoCivil.UNIAO_ESTAVEL)) {

                if (entity.getConjuge() != null) {
                    entity.getConjuge().setConjuge(null);
                    entity.setConjuge(null);
                }
            }

            if (entity.getConjuge() != null && entity.getConjuge().getEstadoCivil() != null && entity.getConjuge().getEstadoCivil().equals(EstadoCivil.CASADO)) {

                Msg.messagemError("O conjuge selecionado já está casado !");
                return false;
            }

//            if (entity.getConjuge() != null) {
//                entity.setEstadoCivil(EstadoCivil.CASADO);
//            }

            if (entity.getTipoDocumento() == null) {
                entity.setTipoDocumento(TipoDocumento.CPF);
            }

            try {

                super.save(entity);
                atualizarConjuge(entity);
                return true;
            } catch (Exception e) {
                System.err.println(e);
            }
        } else {
            Msg.messagemError("Documento do proprietário já foi cadastrado !");
            return false;
        }

        return false;
    }

    private void atualizarConjuge(Proprietario proprietario) {

        if (proprietario.getConjuge() != null) {

            proprietario.getConjuge().setConjuge(proprietario);
            proprietario.getConjuge().setEndereco(proprietario.getEndereco());
            proprietario.getConjuge().setEstadoCivil(EstadoCivil.CASADO);

            update(proprietario.getConjuge());
        }

    }

    /**
     * Atualiza um Proprietario
     *
     * @param entity proprietario a ser atualizado
     */
    @Override
    public void update(Proprietario entity) {

        entity = verificarProprietario(entity);

        if (entity.getTelefone() != null && !entity.getTelefone().isEmpty()) {
            entity.setTelefone(Caracter.removecaracter(entity.getTelefone()));
        }

        super.update(entity);
        updateAnexos(entity);
    }

    public List<Anexo> getAnexos(Proprietario p) {
        String sql = "select a from Proprietario p join p.anexos a where p.id = " + p.getId();
        return getEntityManager().createQuery(sql).getResultList();
    }

    @Override
    public void updateAnexos(Proprietario p) {

        p.setAnexos(getAnexos(p));
        super.updateAnexos(p);
    }

    /**
     * Remove os caracteres que são utilizados como máscara incluindo o objeto Endereço
     *
     * @param p entidade a ser removido os caracteres
     */
    public void removeCaracter(Proprietario p) {
        if (p.getCpf() != null) {
            p.setCpf(Caracter.removecaracter(p.getCpf()));
        }
        if (p.getCnpj() != null) {
            p.setCnpj(Caracter.removecaracter(p.getCnpj()));
        }
    }

    @Override
    @RolesAllowed(GrupoUtilitario.ADMINISTRADOR)
    public void delete(Proprietario entity) {

        Imovel imovel = new Imovel();
        imovel.setProprietarios(new ArrayList<Proprietario>());
        imovel.getProprietarios().add(entity);

        List<Imovel> imoveis = imovelServico.find(imovel, null, null);

        if (imoveis == null || imoveis.isEmpty()) {
            entity.setAtivo(false);
            update(entity);
        } else {
            Msg.messagemWarn("Proprietário não pode ser removido pois existe pelo menos um imóvel em seu nome !");
        }

    }

    public Long findCountImovelProprietario(Proprietario proprietario, Boolean ativo) {
        String sql = "SELECT count(i) FROM Imovel i JOIN i.proprietarios p WHERE p = :p AND i.ativo = :ativo";

        Query query = getEntityManager().createQuery(sql);
        query.setParameter("p", proprietario);
        query.setParameter("ativo", ativo);

        return (Long) query.getSingleResult();
    }

    public List<Proprietario> getProprietarioImovel(Long i) {
        String sql = "SELECT p FROM Imovel i JOIN i.proprietarios p where i.id = :id";
        Query query = getEntityManager().createQuery(sql);
        query.setParameter("id", i);
        return (List<Proprietario>) query.getResultList();
    }

    /**
     *
     * Limpa os campos que não correspondem ao tipo de documento da entidade
     *
     * @param entity
     * @return entity
     */
    public Proprietario verificarProprietario(Proprietario entity) {
        if (entity.getTipoDocumento() != null) {
            if (entity.getTipoDocumento().equals(TipoDocumento.CPF)) {
                entity = limpaCamposPessoaJuridica(entity);
            } else {
                entity = limpaCamposPessoaFisica(entity);
            }
        } else {
            if (entity.getNome() != null && !entity.getNome().equals("")) {
                entity = limpaCamposPessoaJuridica(entity);
            } else {
                entity = limpaCamposPessoaFisica(entity);
            }
        }

        if (entity.getTipoDocumento() == null || entity.getTipoDocumento().equals(TipoDocumento.CPF)) {
            if (entity.getCpf() != null && !entity.getCpf().equals("")) {
                entity.setCpf(Caracter.removecaracter(entity.getCpf()));
            }
            if (entity.getRg() != null && !entity.getRg().equals("")) {
                entity.setRg(Caracter.removecaracter(entity.getRg()));
            }
        } else {
            if (entity.getCnpj() != null && !entity.getCnpj().equals("")) {
                entity.setCnpj(Caracter.removecaracter(entity.getCnpj()));
            }
        }

        return entity;
    }

    public Proprietario limpaCamposPessoaFisica(Proprietario p) {
        p.setNome(null);
        p.setCpf(null);
        p.setRg(null);
        p.setProfissao(null);
        p.setDataNasc(null);
        p.setLocalTrabalho(null);

        return p;
    }

    public Proprietario limpaCamposPessoaJuridica(Proprietario p) {
        p.setNomeFantasia(null);
        p.setCnpj(null);

        return p;
    }

    @Override
    public List<Proprietario> find(Proprietario proprietario, Integer first, Integer pageSize) {
        String select = "SELECT p ";
        String sql = " FROM Proprietario p WHERE ";
        String orderBy = " order by p.id asc";

        if (proprietario.getTipoDocumento().equals(TipoDocumento.CPF)) {
            if (proprietario.getNome() != null && !proprietario.getNome().equals("")) {
                sql += " lower(p.nome) like lower(:name) and lower(p.nome) not like lower('%vel fechado%') and ";
            }
            if (proprietario.getCpf() != null && !proprietario.getCpf().equals("")) {
                sql += " lower(p.cpf) like lower(:cpf) and ";
            }
        }
        if (proprietario.getTipoDocumento().equals(TipoDocumento.CNPJ)) {

            if (proprietario.getNomeFantasia() != null && !proprietario.getNomeFantasia().equals("")) {
                sql += " lower(p.nomeFantasia) like lower(:nomeFantasia) and lower(p.nomeFantasia) not like lower('%vel fechado%') and ";
            }
            if (proprietario.getCnpj() != null && !proprietario.getCnpj().equals("")) {
                sql += " lower(p.cnpj) like lower(:cnpj) and  ";
            }
        }

        if (proprietario.getEstadoCivil() != null) {
            sql += " p.estadoCivil LIKE :estadoCivil AND ";
        }

        sql += " p.ativo = true";

        Query query = getEntityManager().createQuery(select.concat(sql).concat(orderBy));

        setQuantidadeRegistros(sql, query, proprietario);

        setParameters(proprietario, query);

        query.setFirstResult(first).setMaxResults(pageSize);

        return query.getResultList();
    }

    @Transient
    private void setParameters(Proprietario proprietario, Query query) {
        if (proprietario.getTipoDocumento() == TipoDocumento.CPF) {
            if (proprietario.getNome() != null && !proprietario.getNome().equals("")) {
                query.setParameter("name", "%" + proprietario.getNome().replaceAll(" ", "%") + "%");
            }
            if (proprietario.getCpf() != null && !proprietario.getCpf().equals("")) {
                query.setParameter("cpf", "%" + proprietario.getCpf() + "%");
            }
        }
        if (proprietario.getTipoDocumento() == TipoDocumento.CNPJ) {
            if (proprietario.getNomeFantasia() != null && !proprietario.getNomeFantasia().equals("")) {
                query.setParameter("nomeFantasia", "%" + proprietario.getNomeFantasia().replaceAll(" ", "%") + "%");
            }
            if (proprietario.getCnpj() != null && !proprietario.getCnpj().equals("")) {
                query.setParameter("cnpj", "%" + proprietario.getCnpj() + "%");
            }
        }

        if (proprietario.getEstadoCivil() != null) {
            query.setParameter("estadoCivil", "%" + proprietario.getEstadoCivil().name() + "%");
        }
    }

    private void setQuantidadeRegistros(String sql, Query query, Proprietario proprietario) {

        String select = "SELECT count(p) ";

        query = getEntityManager().createQuery(select + sql);

        setParameters(proprietario, query);

        quantidadeRegistrosResults = (Long) query.getSingleResult();
    }

    @Override
    public Long quantidadeRegistros() {
        return quantidadeRegistrosResults;
    }

    public String getNomeProprietarios(List<Proprietario> proprietarios) {
        StringBuilder sb = new StringBuilder();
        Proprietario proprietario;

        for (int i = 0; i < proprietarios.size(); i++) {
            if (proprietarios.size() > 1 && i > 0) {
                if (i < proprietarios.size() - 1) {
                    sb.append(", ");
                } else {
                    sb.append(" e ");
                }
            }

            proprietario = proprietarios.get(i);

            if (proprietarios != null && proprietario != null) {

                proprietario = proprietarios.get(i);

                if (proprietario.getTipoDocumento() != null) {
                    if (proprietario.getTipoDocumento().equals(TipoDocumento.CPF)) {
                        sb.append(proprietario.getNome());
                    } else {
                        if (proprietario.getNomeFantasia() != null && !proprietario.getNomeFantasia().isEmpty()) {
                            sb.append(proprietarios.get(i).getNomeFantasia());
                        } else {
                            sb.append(proprietarios.get(i).getNome());
                        }
                    }
                } else {
                    if (proprietario.getNome() != null && !proprietario.getNome().equals("")) {
                        sb.append(proprietario.getNome());
                    } else {
                        if (proprietario.getNomeFantasia() != null && !proprietario.getNomeFantasia().isEmpty()) {
                            sb.append(proprietarios.get(i).getNomeFantasia());
                        } else {
                            sb.append(proprietarios.get(i).getNome());
                        }
                    }
                }
            }
        }
        return sb.toString();
    }

    public void relDeclaracao(HashMap<String, Object> parametros, Relatorio r) {
        RelatorioServico.genReport(parametros, null, r);
    }

    public void copiaAnexos() {
//        File base = new File("/opt/Atlas/uploads");
//        base.mkdirs();
//        entidadeAnexos(Entidade.IMOVEL);
//        entidadeAnexos(Entidade.PROPRIETARIO);
//        entidadeAnexos(Entidade.PREFEITURA);
//        entidadeAnexos(Entidade.LOCALIDADE);
//        entidadeAnexos(Entidade.AFORAMENTO);
    }

    enum Entidade {

        IMOVEL("/opt/Atlas/uploads/logImovel.txt",
        "/opt/Atlas/uploads/imovel/",
        "select distinct i.id from Imovel i order by i.id"),
        AFORAMENTO("/opt/Atlas/uploads/logAforamento.txt",
        "/opt/Atlas/uploads/aforamento/",
        "select distinct i.id from Aforamento i order by i.id"),
        PREFEITURA("/opt/Atlas/uploads/logPrefeitura.txt",
        "/opt/Atlas/uploads/prefeitura/",
        "select distinct i.id from Prefeitura i order by i.id"),
        LOCALIDADE("/opt/Atlas/uploads/logLocalidade.txt",
        "/opt/Atlas/uploads/localidade/",
        "select distinct i.id from Localidade i order by i.id"),
        PROPRIETARIO("/opt/Atlas/uploads/logProprietario.txt",
        "/opt/Atlas/uploads/proprietario/",
        "select distinct p.id from Proprietario p order by p.id");
        private String pathLog;
        private String pathBase;
        private String qIds;

        Entidade(String pathLog, String pathBase, String qIds) {
            this.pathLog = pathLog;
            this.pathBase = pathBase;
            this.qIds = qIds;
        }

        public String getPathBase() {
            return pathBase;
        }

        public String getPathLog() {
            return pathLog;
        }

        public String getqIds() {
            return qIds;
        }
    }

    private void entidadeAnexos(Entidade entidade) {
        try {
            File log = new File(entidade.getPathLog());
            if (!log.exists()) {
                try {
                    log.createNewFile();
                } catch (IOException ex) {
                    System.out.println("Não foi possível gerar arquivo de log para " + entidade.getPathLog());
                }
            }
            System.setOut(new PrintStream(log));

            File fileBase = new File(entidade.getPathBase());
            fileBase.mkdirs();

            File fileAnexo;
            File miniFileAnexo;
            String pathParentId;
            File fileParentId;
            FileOutputStream outputStreamCopiaAnexo = null;

            Query query = getEntityManager().createQuery(entidade.getqIds());
            List listIds = query.getResultList();

            List<Anexo> anexos = new ArrayList<Anexo>();

            for (Object id : listIds) {
                anexos.clear();
                anexos = anexosEntidade((Long) id, entidade);
                if (!anexos.isEmpty()) {

                    System.out.println("#" + id + " : " + anexos.size());

                    for (Anexo anexo : anexos) {
                        fileAnexo = new File("/opt/uploads/" + anexo.getNome());
                        miniFileAnexo = new File("/opt/uploads/" + "thumbnail." + anexo.getNome());

                        System.out.print("-" + anexo.getId() + " : ");
                        if (fileAnexo.exists()) {
                            System.out.print("existe");
                            pathParentId = entidade.getPathBase() + id;
                            fileParentId = new File(pathParentId);
                            fileParentId.mkdirs();
                            pathParentId += "/" + anexo.getNome();
                            try {
                                outputStreamCopiaAnexo = new FileOutputStream(pathParentId);
                                outputStreamCopiaAnexo.write(getBytes(fileAnexo));
                                outputStreamCopiaAnexo.close();
                                System.out.println(", copiado");
                            } catch (IOException ex) {
                                System.out.println(", nao copiado");
                            } finally {
                                try {
                                    outputStreamCopiaAnexo.close();
                                } catch (IOException ex) {
                                }
                            }
                        } else {
                            System.out.println("nao existe");
                        }
                        System.out.print("-" + anexo.getId() + " mini : ");
                        if (miniFileAnexo.exists()) {
                            System.out.print("existe");
                            pathParentId = entidade.getPathBase() + id;
                            fileParentId = new File(pathParentId);
                            fileParentId.mkdirs();
                            pathParentId += "/" + "thumbnail." + anexo.getNome();
                            try {
                                outputStreamCopiaAnexo = new FileOutputStream(pathParentId);
                                outputStreamCopiaAnexo.write(getBytes(miniFileAnexo));
                                outputStreamCopiaAnexo.close();
                                System.out.println(", copiado");
                            } catch (IOException ex) {
                                System.out.println(", nao copiado");
                            } finally {
                                try {
                                    outputStreamCopiaAnexo.close();
                                } catch (IOException ex) {
                                }
                            }
                        } else {
                            System.out.println("nao existe");
                        }
                    }
                }
            }

        } catch (FileNotFoundException ex) {
        }

        System.err.println("Fim = " + entidade.name());
    }

    private List<Anexo> anexosEntidade(Long id, Entidade entidade) {
        String q = "";

        switch (entidade) {
            case IMOVEL:
                q = "select a.id, a.nome, a.url from anexo a "
                        + "where (a.imovel_id = " + id + " or a.imovelcroqui_id = " + id + ") and a.ativo = true";
                break;
            case PROPRIETARIO:
                q = "select a.id, a.nome, a.url from anexo a join proprietario_anexo pa on pa.anexos_id = a.id "
                        + "where a.ativo = true and pa.proprietario_id = " + id;
                break;
            case AFORAMENTO:
                q = "select a.id, a.nome, a.url from anexo a join aforamento_anexo pa on pa.anexos_id = a.id "
                        + "where a.ativo = true and pa.aforamento_id = " + id;
                break;
            case PREFEITURA:
                q = "select a.id, a.nome, a.url from anexo a, prefeitura p "
                        + "where a.ativo = true and (p.logo_id = a.id or p.logoRegularizacaoFundiaria_id = a.id) "
                        + "and p.id = " + id;
                break;
            case LOCALIDADE:
                q = "select a.id, a.nome, a.url from anexo a, localidade l "
                        + "where a.ativo = true and l.anexo_id = a.id) "
                        + "and l.id = " + id;
                break;
        }

        List<Object[]> objects = getEntityManager().createNativeQuery(q).getResultList();
        List<Anexo> anexos = new ArrayList<Anexo>();
        for (Object[] o : objects) {
            Anexo a = new Anexo();
            a.setId((Long) o[0]);
            a.setNome((String) o[1]);
            a.setUrl((String) o[2]);

            anexos.add(a);
        }

        return anexos;
    }

    public static byte[] getBytes(File file) {
        int length = (int) file.length();
        byte[] bytes = new byte[length];
        FileInputStream inFile = null;
        try {
            inFile = new FileInputStream(file);
            inFile.read(bytes, 0, length);

        } catch (IOException e) {
            System.err.println("File not found!");
        }
        return bytes;
    }
}
